Just Call Me Internet/Just Call Me Internet.iso/prog/atari/m2/cat3src/magic/i/magicstr.i

Modula Implementation | 1997-10-26 | 6.7 KB | 200 lines

(*----------------------------------------------------------------------*
 *                                                                      *
 *         MAGIC   Modula's  All purpose  GEM  Interface  Cadre         *
 *                 ÿ         ÿ            ÿ    ÿ          ÿ             *
 *----------------------------------------------------------------------*
 * Version 3.30  02.02.1992     (C)90/91/92 by Peter Hellinger Software *
 *----------------------------------------------------------------------*
 *            Dieses Modul ist urheberrechtlich geschtzt.              *
 *                                                                      *
 * Die Ver”ffentlichung des Quelltextes oder Teilen daraus in schrift-  *
 * licher Form, insbesondere in Zeitschriften, sowie die Verbreitung    *
 * ber Public-Domain-H„ndler bedarf der ausdrcklichen schriftlichen   *
 * Genehmigung des Autors!                                              *
 *                                                                      *
 * Der Autor gibt hiermit die ausdrckliche Erlaubnis, das Modul jeder- *
 * zeit auch im Quelltext weiterzugegeben, sofern dessen Text und ins-  *
 * besondere dieser Urheberrechts-Vermerk nicht ver„ndert wird, und     *
 * durch die Weitergabe kein finanzieller Nutzen entsteht. Der Autor    *
 * beh„lt sich das Recht vor, diese Erlaubnis jederzeit u. ohne Angaben *
 * von Grnden zu widerrufen.                                           *
 *----------------------------------------------------------------------*)

IMPLEMENTATION MODULE MagicStrings;

(*----------------------------------------------------------------------*
 * Original (C) by Johannes Leckebusch/Peter Hellinger   MM2-Modula-2   *
 *                                                                      *
 * In diesem Modul werden fr Index-Z„hler INTEGER-Variable benutzt,    *
 * weil es sonst bei Ausdrcken der Form "Laenge - 1" zu Bereichsfehler *
 * kommt, wenn L„nge = 0 und L„nge = TYPE CARDINAL.                     *
 *----------------------------------------------------------------------*
 * Int. Vers | Datum    | Name | Žnderung                               *
 *-----------+----------+------+----------------------------------------*
 *  3.00     | 18.01.92 |  Hp  |                                        *
 *-----------+----------+------+----------------------------------------*)



(* IMPLEMENTATION FšR  >>> Megamax-Modula-2 <<< *)
(*                                              *)
(*$R-   Range-Checks                            *)
(*$S-   Stack-Check                             *)
(*                                              *)
(*----------------------------------------------*)






FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6,
                        Bit7, Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14,
                        Bit15, LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL,
                        sBITSET, lINTEGER, lCARDINAL, lWORD, lBITSET,
                        CastToChar, CastToByte, CastToByteset, CastToInt,
                        CastToCard, CastToBitset, CastToWord, CastToLInt,
                        CastToLCard, CastToLBitset, CastToLWord, CastToAddr,
                        TosVersion, Accessory, Basepage, SysHeader, TosDate;







IMPORT Strings;

CONST   Ch0 =   0C;

PROCEDURE Length (REF str: ARRAY OF CHAR): sCARDINAL;
BEGIN
 RETURN LENGTH (str);
END Length;

PROCEDURE Compare (REF s1, s2: ARRAY OF CHAR): Relation;
VAR equ: Strings.Relation;
BEGIN
 equ:= Strings.Compare (s1, s2);
 CASE equ OF
  Strings.less:    RETURN less;|
  Strings.equal:   RETURN equal;|
  Strings.greater: RETURN greater;|
 END;
END Compare;

PROCEDURE Equal (REF s1, s2: ARRAY OF CHAR): BOOLEAN;
BEGIN
 RETURN Strings.StrEqual (s1, s2);
END Equal;





PROCEDURE Assign (REF q: ARRAY OF CHAR; VAR z: ARRAY OF CHAR);
VAR i, l, hq, hz: sCARDINAL;
BEGIN
 FOR i:= 0 TO HIGH (z) DO
  IF (i > HIGH (q)) OR (q[i] = Ch0) THEN  z[i]:= Ch0;  RETURN;  END;
  z[i]:= q[i];
 END;
END Assign;

PROCEDURE Pos (REF substr, str: ARRAY OF CHAR;
               start: sCARDINAL; dowild: BOOLEAN): sCARDINAL;
CONST wild =  '*';
      joker = '?';
VAR s, j, jl, sl, maxs, max, pos: CARDINAL;
    ch: CHAR ;
BEGIN
 jl:= Length (substr);  sl:= Length (str);  max:= HIGH (str) + 1;  pos:= 0;
 IF (jl = 0) OR (sl = 0) OR (start + jl > sl) THEN  RETURN max; END;
 maxs:= sl - jl;
 LOOP (* 1 *)
  j:= 0;
  s:= start;
  LOOP (* 2 *)
   WHILE (substr[j] # 0C) AND
         (dowild AND ((substr[j] = wild) OR (substr[j] = joker))) AND
         (str[s] # 0C) DO
    ch:= substr[j];  INC (j);
    IF (ch = wild) AND dowild THEN
     ch:= substr[j];
     WHILE (str[s] # ch) AND (str[s] # 0C) DO  INC (s);  END;
    ELSE
     INC (s);
    END;
   END; (* WHILE *)
   IF j >= jl THEN  RETURN start;  END;
   IF substr[j] # str[s] THEN  EXIT; (* 2 *)  END;
   INC (j);
   INC (s);
   IF j >= jl THEN  RETURN start;  END;
  END; (* 2 *)
  INC (start);
  IF start > maxs THEN  RETURN max; END;
 END; (* 1 *)
 RETURN max;
END Pos;

PROCEDURE Insert (REF substr: ARRAY OF CHAR; VAR str: ARRAY OF CHAR; inx: sCARDINAL);
VAR i, in, h, l, l1: sINTEGER;
BEGIN
 l1:= Length (substr);  h:= HIGH (str);  in:= inx;
 IF l1 = 0 THEN RETURN END;
 l:= Length (str);  l:= l + l1 - 1;
 FOR i:= l TO (in + l1) BY -1 DO  str[i]:= str[i - l1];  END;
 IF (l + 1) <= h THEN str [l + 1]:= Ch0; END;
 FOR i:= 0 TO l1 - 1 DO  str[i + in]:= substr[i];  END;
END Insert;

PROCEDURE Delete (VAR str: ARRAY OF CHAR; inx, len: sCARDINAL);
VAR i, l, h, in, le: sINTEGER;
BEGIN
 l:= Length (str);  in:= inx;  le:= len;  h:= HIGH (str);
 FOR i:= in TO (l - le) - 1 DO  str[i]:= str[i + le];  END;
 IF (l - le) <= h THEN  str[l - le]:= Ch0;
 END;
END Delete;

PROCEDURE Append (REF substr: ARRAY OF CHAR; VAR str: ARRAY OF CHAR);
VAR i, j, l: sCARDINAL;
BEGIN
 l:= Length (str);  j:= 0;
 FOR i:= l TO HIGH (str) DO
  IF (substr[j] = Ch0) OR (j > HIGH (substr)) THEN
   str[i]:= Ch0;
   RETURN;
  END;
  str[i]:= substr[j];  INC (j);
 END;
END Append;

PROCEDURE Copy (REF str: ARRAY OF CHAR; inx, len: sCARDINAL;
                VAR result: ARRAY OF CHAR);
VAR i, in, le, h: sINTEGER;
BEGIN
 in:= inx;  le:= len;  h:= HIGH (result);
 FOR i:= 0 TO le - 1 DO  result[i]:= str[in + i];  END;
 IF le <= h THEN  result [le]:= Ch0;  END;
END Copy;


PROCEDURE CAPS (VAR str: ARRAY OF CHAR);
VAR c: sCARDINAL;
BEGIN
 FOR c:= 0 TO HIGH (str) DO
  IF str[c] = 0C THEN  RETURN;  END;
  str[c]:= Cap (str[c]);
 END;
END CAPS;

PROCEDURE Cap (ch: CHAR): CHAR;
BEGIN
   RETURN CAP (ch);   (* MM2 konvertiert selbst *)

END Cap;

END MagicStrings.